﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Linq;

namespace LinqToBing.Bing.Wrapper.ExtensionMethods
{
    public static class XElementExt
    {
        #region class XElement

        #region from an Attribute
        /// <summary>
        /// Ritorna una stringa da un attributo di un elemento.
        /// </summary>
        /// <param name="xelem">L'elemento da cui trarre il valore.</param>
        /// <param name="sAttributeName">Il nome dell'attributo da cui prendere il  valore.</param>
        /// <returns>Ritorna la stringa trovata, o string.empty in caso di errore o attributo non presente.</returns>
        /// <remarks>Extension method creata per comodità stilistica.</remarks>
        public static string GetStringFromAttribute(this XElement xelem, string sAttributeName)
        {
            string sResult = string.Empty;
            try
            {
                sResult = (xelem.Attribute(sAttributeName) != null) ? (xelem.Attribute(sAttributeName).Value) : string.Empty;
            }
            catch
            { }
            return sResult;
        }
        /// <summary>
        /// Ritorna uno short da un attributo di un elemento.
        /// </summary>
        /// <param name="xelem">L'elemento da cui trarre il valore.</param>
        /// <param name="sAttributeName">Il nome dell'attributo da cui prendere il  valore.</param>
        /// <returns>Ritorna il valore trovato, o -1 in caso di errore o attributo non presente.</returns>
        /// <remarks>Extension method creata per comodità stilistica.</remarks>
        public static short GetShortFromAttribute(this XElement xelem, string sAttributeName)
        {
            short shResult = 0;
            try
            {
                string sResult = xelem.GetStringFromAttribute(sAttributeName);
                shResult = (sResult != string.Empty) ? short.Parse(sResult) : short.Parse("0");
            }
            catch
            { }
            return shResult;
        }
        /// <summary>
        /// Ritorna un intero da un attributo di un elemento.
        /// </summary>
        /// <param name="xelem">L'elemento da cui trarre il valore.</param>
        /// <param name="sAttributeName">Il nome dell'attributo da cui prendere il  valore.</param>
        /// <returns>Ritorna l'intero trovato, o -1 in caso di errore o attributo non presente.</returns>
        /// <remarks>Extension method creata per comodità stilistica.</remarks>
        public static int GetInt32FromAttribute(this XElement xelem, string sAttributeName)
        {
            int iResult = 0;
            try
            {
                string sResult = xelem.GetStringFromAttribute(sAttributeName);
                iResult = (sResult != string.Empty) ? int.Parse(sResult) : 0;
            }
            catch
            { }
            return iResult;
        }
        /// <summary>
        /// Ritorna un boolean da un attributo di un elemento.
        /// </summary>
        /// <param name="xelem">L'elemento da cui trarre il valore.</param>
        /// <param name="sAttributeName">Il nome dell'attributo da cui prendere il  valore.</param>
        /// <returns>Ritorna il bool trovato, o false in caso di errore o attributo non presente.</returns>
        /// <remarks>Extension method creata per comodità stilistica.</remarks>
        public static bool GetBoolFromAttribute(this XElement xelem, string sAttributeName)
        {
            bool bResult = false;
            try
            {
                string sResult = xelem.GetStringFromAttribute(sAttributeName);
                bResult = (sResult != string.Empty) ? bool.Parse(sResult) : false;
            }
            catch
            { }
            return bResult;
        }
        /// <summary>
        /// Ritorna un boolean da un elemento.
        /// </summary>
        /// <param name="xelem">L'elemento da cui trarre il valore.</param>
        /// <param name="sElementName">Il nome dell'elemento da cui prendere il  valore.</param>
        /// <returns>Ritorna il bool trovato, o false in caso di errore o attributo non presente.</returns>
        /// <remarks>Extension method creata per comodità stilistica.</remarks>
        public static bool GetBoolFromElement(this XElement xelem, string sElementName)
        {
            bool bResult = false;
            try
            {
                string sResult = xelem.GetStringFromElement(sElementName);
                bResult = (sResult != string.Empty) ? bool.Parse(sResult) : false;
            }
            catch
            { }
            return bResult;
        }
        /// <summary>
        /// Ritorna un datetime da un attributo di un elemento.
        /// </summary>
        /// <param name="xelem">L'elemento da cui trarre il valore.</param>
        /// <param name="sAttributeName">Il nome dell'attributo da cui prendere il  valore.</param>
        /// <returns>Ritorna il datetime trovato, o il min datetime in caso di errore o attributo non presente.</returns>
        /// <remarks>Extension method creata per comodità stilistica.</remarks>
        public static DateTime GetDateTimeFromAttribute(this XElement xelem, string sAttributeName)
        {
            DateTime dtResult = DateTime.MinValue;
            try
            {
                string sResult = xelem.GetStringFromAttribute(sAttributeName);
                dtResult = (sResult != string.Empty) ? DateTime.Parse(sResult) : DateTime.MinValue;
            }
            catch
            { }
            return dtResult;
        }
        #endregion
        #region from an Element
        /// <summary>
        /// Ritorna una stringa da un elemento.
        /// </summary>
        /// <param name="xelem">L'elemento da cui trarre il valore.</param>
        /// <param name="sAttributeName">Il nome dell'elemento da cui prendere il  valore.</param>
        /// <returns>Ritorna la stringa trovata, o string.empty in caso di errore o elemento non presente.</returns>
        /// <remarks>Extension method creata per comodità stilistica.</remarks>
        public static string GetStringFromElement(this XElement xelem, string sElementName)
        {
            string sResult = string.Empty;
            try
            {
                XElement xe = (xelem.Name.ToString().Equals(sElementName) ? xelem : xelem.Element(sElementName));
                sResult = (xe != null) ? (xe.Value) : string.Empty;
            }
            catch
            { }
            return sResult;
        }
        /// <summary>
        /// Ritorna una Uri da un elemento.
        /// </summary>
        /// <param name="xelem">L'elemento da cui trarre il valore.</param>
        /// <param name="sAttributeName">Il nome dell'elemento da cui prendere il  valore.</param>
        /// <returns>Ritorna l'Uri dalla stringa trovata, o null in caso di errore o elemento non presente.</returns>
        public static Uri GetUriFromElement(this XElement xelem, string sElementName)
        {
            Uri sResult = null;
            try
            {
                sResult = new Uri(xelem.GetStringFromElement(sElementName));
            }
            catch
            { }
            return sResult;
        }
        /// <summary>
        /// Ritorna uno short da un elemento.
        /// </summary>
        /// <param name="xelem">L'elemento da cui trarre il valore.</param>
        /// <param name="sAttributeName">Il nome dell'elemento da cui prendere il  valore.</param>
        /// <returns>Ritorna il valore trovato, o -1 in caso di errore o elemento non presente.</returns>
        /// <remarks>Extension method creata per comodità stilistica.</remarks>
        public static short GetShortFromElement(this XElement xelem, string sElementName)
        {
            short shResult = 0;
            try
            {
                string sResult = xelem.GetStringFromElement(sElementName);
                shResult = (sResult != string.Empty) ? short.Parse(sResult) : short.Parse("0");
            }
            catch
            { }
            return shResult;
        }
        /// <summary>
        /// Ritorna un intero da un elemento.
        /// </summary>
        /// <param name="xelem">L'elemento da cui trarre il valore.</param>
        /// <param name="sAttributeName">Il nome dell'elemento da cui prendere il  valore.</param>
        /// <returns>Ritorna l'intero trovato, o -1 in caso di errore o attributo non presente.</returns>
        /// <remarks>Extension method creata per comodità stilistica.</remarks>
        public static int GetInt32FromElement(this XElement xelem, string sElementName)
        {
            int iResult = 0;
            try
            {
                string sResult = xelem.GetStringFromElement(sElementName);
                iResult = (sResult != string.Empty) ? int.Parse(sResult) : 0;
            }
            catch
            { }
            return iResult;
        }
        /// <summary>
        /// Ritorna un DateTime da un elemento.
        /// </summary>
        /// <param name="xelem">L'elemento da cui trarre il valore.</param>
        /// <param name="sAttributeName">Il nome dell'elemento da cui prendere il  valore.</param>
        /// <returns>Ritorna il datetime trovato, o -1 in caso di errore o attributo non presente.</returns>
        /// <remarks>Extension method creata per comodità stilistica.</remarks>
        public static DateTime GetDateTimeFromElement(this XElement xelem, string sElementName)
        {
            DateTime dtResult = DateTime.MinValue;
            try
            {
                string sResult = xelem.GetStringFromElement(sElementName);
                dtResult = (sResult != string.Empty) ? DateTime.Parse(sResult) : DateTime.MinValue;
            }
            catch
            { }
            return dtResult;
        }
        #endregion
        #region from an Attribute into an Element
        /// <summary>
        /// Ritorna un intero da un attributo di elemento.
        /// </summary>
        /// <param name="xelem"></param>
        /// <param name="sElementName"></param>
        /// <param name="sAttributeName"></param>
        /// <returns></returns>
        public static int GetInt32FromElementAttribute(this XElement xelem, string sElementName, string sAttributeName)
        {
            int iResult = 0;
            try
            {
                XElement xeleminside = xelem.Element(sElementName);
                if (xeleminside != null)
                {
                    string sResult = xeleminside.GetStringFromAttribute(sAttributeName);
                    iResult = (sResult != string.Empty) ? int.Parse(sResult) : 0;
                }
            }
            catch
            { }
            return iResult;
        }
        #endregion

        #endregion

    }
}
